/*
    * Copyright (c) 2000, 2007, Oracle and/or its affiliates. All rights reserved.
    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    *
    * This code is free software; you can redistribute it and/or modify it
    * under the terms of the GNU General Public License version 2 only, as
    * published by the Free Software Foundation.  Oracle designates this
    * particular file as subject to the "Classpath" exception as provided
    * by Oracle in the LICENSE file that accompanied this code.
   *
   * This code is distributed in the hope that it will be useful, but WITHOUT
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   * version 2 for more details (a copy is included in the LICENSE file that
   * accompanied this code).
   *
   * You should have received a copy of the GNU General Public License version
   * 2 along with this work; if not, write to the Free Software Foundation,
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  
  package sun.print;
  
  import java.awt.Dimension;
  import java.awt.Frame;
  import java.awt.Graphics;
  import java.awt.Graphics2D;
  import java.awt.PrintJob;
  import java.awt.JobAttributes;
  import java.awt.JobAttributes.*;
  import java.awt.PageAttributes;
  import java.awt.PageAttributes.*;
  
  import java.awt.print.PageFormat;
  import java.awt.print.Paper;
  import java.awt.print.Printable;
  import java.awt.print.PrinterException;
  import java.awt.print.PrinterJob;
  
  import java.io.File;
  import java.io.FilePermission;
  import java.io.IOException;
  
  import java.net.URI;
  import java.net.URISyntaxException;
  
  import java.util.ArrayList;
  import java.util.Properties;
  
  import javax.print.PrintService;
  import javax.print.attribute.HashPrintRequestAttributeSet;
  import javax.print.attribute.PrintRequestAttributeSet;
  import javax.print.attribute.ResolutionSyntax;
  import javax.print.attribute.Size2DSyntax;
  import javax.print.attribute.standard.Chromaticity;
  import javax.print.attribute.standard.Copies;
  import javax.print.attribute.standard.Destination;
  import javax.print.attribute.standard.DialogTypeSelection;
  import javax.print.attribute.standard.JobName;
  import javax.print.attribute.standard.MediaSize;
  import javax.print.attribute.standard.PrintQuality;
  import javax.print.attribute.standard.PrinterResolution;
  import javax.print.attribute.standard.SheetCollate;
  import javax.print.attribute.standard.Sides;
  import javax.print.attribute.standard.Media;
  import javax.print.attribute.standard.OrientationRequested;
  import javax.print.attribute.standard.MediaSizeName;
  import javax.print.attribute.standard.PageRanges;
  
  import sun.print.SunPageSelection;
  import sun.print.SunMinMaxPage;
  
  /**
   * A class which initiates and executes a print job using
   * the underlying PrinterJob graphics conversions.
   *
   * @see Toolkit#getPrintJob
   *
   */
  public class PrintJob2D extends PrintJob implements Printable, Runnable {
  
      private static final MediaType SIZES[] = {
          MediaType.ISO_4A0, MediaType.ISO_2A0, MediaType.ISO_A0,
          MediaType.ISO_A1, MediaType.ISO_A2, MediaType.ISO_A3,
          MediaType.ISO_A4, MediaType.ISO_A5, MediaType.ISO_A6,
          MediaType.ISO_A7, MediaType.ISO_A8, MediaType.ISO_A9,
          MediaType.ISO_A10, MediaType.ISO_B0, MediaType.ISO_B1,
          MediaType.ISO_B2, MediaType.ISO_B3, MediaType.ISO_B4,
          MediaType.ISO_B5, MediaType.ISO_B6, MediaType.ISO_B7,
          MediaType.ISO_B8, MediaType.ISO_B9, MediaType.ISO_B10,
          MediaType.JIS_B0, MediaType.JIS_B1, MediaType.JIS_B2,
          MediaType.JIS_B3, MediaType.JIS_B4, MediaType.JIS_B5,
          MediaType.JIS_B6, MediaType.JIS_B7, MediaType.JIS_B8,
          MediaType.JIS_B9, MediaType.JIS_B10, MediaType.ISO_C0,
          MediaType.ISO_C1, MediaType.ISO_C2, MediaType.ISO_C3,
         MediaType.ISO_C4, MediaType.ISO_C5, MediaType.ISO_C6,
         MediaType.ISO_C7, MediaType.ISO_C8, MediaType.ISO_C9,
         MediaType.ISO_C10, MediaType.ISO_DESIGNATED_LONG,
         MediaType.EXECUTIVE, MediaType.FOLIO, MediaType.INVOICE,
         MediaType.LEDGER, MediaType.NA_LETTER, MediaType.NA_LEGAL,
         MediaType.QUARTO, MediaType.A, MediaType.B,
         MediaType.C, MediaType.D, MediaType.E,
         MediaType.NA_10X15_ENVELOPE, MediaType.NA_10X14_ENVELOPE,
         MediaType.NA_10X13_ENVELOPE, MediaType.NA_9X12_ENVELOPE,
         MediaType.NA_9X11_ENVELOPE, MediaType.NA_7X9_ENVELOPE,
         MediaType.NA_6X9_ENVELOPE, MediaType.NA_NUMBER_9_ENVELOPE,
         MediaType.NA_NUMBER_10_ENVELOPE, MediaType.NA_NUMBER_11_ENVELOPE,
         MediaType.NA_NUMBER_12_ENVELOPE, MediaType.NA_NUMBER_14_ENVELOPE,
         MediaType.INVITE_ENVELOPE, MediaType.ITALY_ENVELOPE,
         MediaType.MONARCH_ENVELOPE, MediaType.PERSONAL_ENVELOPE
     };
 
     /* This array maps the above array to the objects used by the
      * javax.print APIs
          */
     private static final MediaSizeName JAVAXSIZES[] = {
         null, null, MediaSizeName.ISO_A0,
         MediaSizeName.ISO_A1, MediaSizeName.ISO_A2, MediaSizeName.ISO_A3,
         MediaSizeName.ISO_A4, MediaSizeName.ISO_A5, MediaSizeName.ISO_A6,
         MediaSizeName.ISO_A7, MediaSizeName.ISO_A8, MediaSizeName.ISO_A9,
         MediaSizeName.ISO_A10, MediaSizeName.ISO_B0, MediaSizeName.ISO_B1,
         MediaSizeName.ISO_B2, MediaSizeName.ISO_B3, MediaSizeName.ISO_B4,
         MediaSizeName.ISO_B5,  MediaSizeName.ISO_B6, MediaSizeName.ISO_B7,
         MediaSizeName.ISO_B8, MediaSizeName.ISO_B9, MediaSizeName.ISO_B10,
         MediaSizeName.JIS_B0, MediaSizeName.JIS_B1, MediaSizeName.JIS_B2,
         MediaSizeName.JIS_B3, MediaSizeName.JIS_B4, MediaSizeName.JIS_B5,
         MediaSizeName.JIS_B6, MediaSizeName.JIS_B7, MediaSizeName.JIS_B8,
         MediaSizeName.JIS_B9, MediaSizeName.JIS_B10, MediaSizeName.ISO_C0,
         MediaSizeName.ISO_C1, MediaSizeName.ISO_C2, MediaSizeName.ISO_C3,
         MediaSizeName.ISO_C4, MediaSizeName.ISO_C5, MediaSizeName.ISO_C6,
         null, null, null, null,
         MediaSizeName.ISO_DESIGNATED_LONG, MediaSizeName.EXECUTIVE,
         MediaSizeName.FOLIO, MediaSizeName.INVOICE, MediaSizeName.LEDGER,
         MediaSizeName.NA_LETTER, MediaSizeName.NA_LEGAL,
         MediaSizeName.QUARTO, MediaSizeName.A, MediaSizeName.B,
         MediaSizeName.C, MediaSizeName.D, MediaSizeName.E,
         MediaSizeName.NA_10X15_ENVELOPE, MediaSizeName.NA_10X14_ENVELOPE,
         MediaSizeName.NA_10X13_ENVELOPE, MediaSizeName.NA_9X12_ENVELOPE,
         MediaSizeName.NA_9X11_ENVELOPE, MediaSizeName.NA_7X9_ENVELOPE,
         MediaSizeName.NA_6X9_ENVELOPE,
         MediaSizeName.NA_NUMBER_9_ENVELOPE,
         MediaSizeName.NA_NUMBER_10_ENVELOPE,
         MediaSizeName.NA_NUMBER_11_ENVELOPE,
         MediaSizeName.NA_NUMBER_12_ENVELOPE,
         MediaSizeName.NA_NUMBER_14_ENVELOPE,
         null, MediaSizeName.ITALY_ENVELOPE,
         MediaSizeName.MONARCH_ENVELOPE, MediaSizeName.PERSONAL_ENVELOPE,
     };
 
 
     // widths and lengths in PostScript points (1/72 in.)
     private static final int WIDTHS[] = {
         /*iso-4a0*/ 4768, /*iso-2a0*/ 3370, /*iso-a0*/ 2384, /*iso-a1*/ 1684,
         /*iso-a2*/ 1191, /*iso-a3*/ 842, /*iso-a4*/ 595, /*iso-a5*/ 420,
         /*iso-a6*/ 298, /*iso-a7*/ 210, /*iso-a8*/ 147, /*iso-a9*/ 105,
         /*iso-a10*/ 74, /*iso-b0*/ 2835, /*iso-b1*/ 2004, /*iso-b2*/ 1417,
         /*iso-b3*/ 1001, /*iso-b4*/ 709, /*iso-b5*/ 499, /*iso-b6*/ 354,
         /*iso-b7*/ 249, /*iso-b8*/ 176, /*iso-b9*/ 125, /*iso-b10*/ 88,
         /*jis-b0*/ 2920, /*jis-b1*/ 2064, /*jis-b2*/ 1460, /*jis-b3*/ 1032,
         /*jis-b4*/ 729, /*jis-b5*/ 516, /*jis-b6*/ 363, /*jis-b7*/ 258,
         /*jis-b8*/ 181, /*jis-b9*/ 128, /*jis-b10*/ 91, /*iso-c0*/ 2599,
         /*iso-c1*/ 1837, /*iso-c2*/ 1298, /*iso-c3*/ 918, /*iso-c4*/ 649,
         /*iso-c5*/ 459, /*iso-c6*/ 323, /*iso-c7*/ 230, /*iso-c8*/ 162,
         /*iso-c9*/ 113, /*iso-c10*/ 79, /*iso-designated-long*/ 312,
         /*executive*/ 522, /*folio*/ 612, /*invoice*/ 396, /*ledger*/ 792,
         /*na-letter*/ 612, /*na-legal*/ 612, /*quarto*/ 609, /*a*/ 612,
         /*b*/ 792, /*c*/ 1224, /*d*/ 1584, /*e*/ 2448,
         /*na-10x15-envelope*/ 720, /*na-10x14-envelope*/ 720,
         /*na-10x13-envelope*/ 720, /*na-9x12-envelope*/ 648,
         /*na-9x11-envelope*/ 648, /*na-7x9-envelope*/ 504,
         /*na-6x9-envelope*/ 432, /*na-number-9-envelope*/ 279,
         /*na-number-10-envelope*/ 297, /*na-number-11-envelope*/ 324,
         /*na-number-12-envelope*/ 342, /*na-number-14-envelope*/ 360,
         /*invite-envelope*/ 624, /*italy-envelope*/ 312,
         /*monarch-envelope*/ 279, /*personal-envelope*/ 261
     };
     private static final int LENGTHS[] = {
         /*iso-4a0*/ 6741, /*iso-2a0*/ 4768, /*iso-a0*/ 3370, /*iso-a1*/ 2384,
         /*iso-a2*/ 1684, /*iso-a3*/ 1191, /*iso-a4*/ 842, /*iso-a5*/ 595,
         /*iso-a6*/ 420, /*iso-a7*/ 298, /*iso-a8*/ 210, /*iso-a9*/ 147,
         /*iso-a10*/ 105, /*iso-b0*/ 4008, /*iso-b1*/ 2835, /*iso-b2*/ 2004,
         /*iso-b3*/ 1417, /*iso-b4*/ 1001, /*iso-b5*/ 729, /*iso-b6*/ 499,
         /*iso-b7*/ 354, /*iso-b8*/ 249, /*iso-b9*/ 176, /*iso-b10*/ 125,
         /*jis-b0*/ 4127, /*jis-b1*/ 2920, /*jis-b2*/ 2064, /*jis-b3*/ 1460,
         /*jis-b4*/ 1032, /*jis-b5*/ 729, /*jis-b6*/ 516, /*jis-b7*/ 363,
         /*jis-b8*/ 258, /*jis-b9*/ 181, /*jis-b10*/ 128, /*iso-c0*/ 3677,
         /*iso-c1*/ 2599, /*iso-c2*/ 1837, /*iso-c3*/ 1298, /*iso-c4*/ 918,
         /*iso-c5*/ 649, /*iso-c6*/ 459, /*iso-c7*/ 323, /*iso-c8*/ 230,
         /*iso-c9*/ 162, /*iso-c10*/ 113, /*iso-designated-long*/ 624,
         /*executive*/ 756, /*folio*/ 936, /*invoice*/ 612, /*ledger*/ 1224,
         /*na-letter*/ 792, /*na-legal*/ 1008, /*quarto*/ 780, /*a*/ 792,
         /*b*/ 1224, /*c*/ 1584, /*d*/ 2448, /*e*/ 3168,
         /*na-10x15-envelope*/ 1080, /*na-10x14-envelope*/ 1008,
         /*na-10x13-envelope*/ 936, /*na-9x12-envelope*/ 864,
         /*na-9x11-envelope*/ 792, /*na-7x9-envelope*/ 648,
         /*na-6x9-envelope*/ 648, /*na-number-9-envelope*/ 639,
         /*na-number-10-envelope*/ 684, /*na-number-11-envelope*/ 747,
         /*na-number-12-envelope*/ 792, /*na-number-14-envelope*/ 828,
         /*invite-envelope*/ 624, /*italy-envelope*/ 652,
         /*monarch-envelope*/ 540, /*personal-envelope*/ 468
     };
 
 
     private Frame frame;
     private String docTitle = "";
     private JobAttributes jobAttributes;
     private PageAttributes pageAttributes;
     private PrintRequestAttributeSet attributes;
 
     /*
      * Displays the native or cross-platform dialog and allows the
      * user to update job & page attributes
      */
 
     /**
      * The PrinterJob being uses to implement the PrintJob.
      */
     private PrinterJob printerJob;
 
     /**
      * The size of the page being used for the PrintJob.
      */
     private PageFormat pageFormat;
 
     /**
      * The PrinterJob and the application run on different
      * threads and communicate through a pair of message
      * queues. This queue is the list of Graphics that
      * the PrinterJob has requested rendering for, but
      * for which the application has not yet called getGraphics().
      * In practice the length of this message queue is always
      * 0 or 1.
      */
     private MessageQ graphicsToBeDrawn = new MessageQ("tobedrawn");
 
     /**
      * Used to communicate between the application's thread
      * and the PrinterJob's thread this message queue holds
      * the list of Graphics into which the application has
      * finished drawing, but that have not yet been returned
      * to the PrinterJob thread. Again, in practice, the
      * length of this message queue is always 0 or 1.
      */
     private MessageQ graphicsDrawn = new MessageQ("drawn");
 
     /**
      * The last Graphics returned to the application via
      * getGraphics. This is the Graphics into which the
      * application is currently drawing.
      */
     private Graphics2D currentGraphics;
 
     /**
      * The zero based index of the page currently being rendered
      * by the application.
      */
     private int pageIndex = -1;
 
     // The following Strings are maintained for backward-compatibility with
     // Properties based print control.
     private final static String DEST_PROP = "awt.print.destination";
     private final static String PRINTER = "printer";
     private final static String FILE = "file";
 
     private final static String PRINTER_PROP = "awt.print.printer";
 
     private final static String FILENAME_PROP = "awt.print.fileName";
 
     private final static String NUMCOPIES_PROP = "awt.print.numCopies";
 
     private final static String OPTIONS_PROP = "awt.print.options";
 
     private final static String ORIENT_PROP = "awt.print.orientation";
     private final static String PORTRAIT = "portrait";
     private final static String LANDSCAPE = "landscape";
 
     private final static String PAPERSIZE_PROP = "awt.print.paperSize";
     private final static String LETTER = "letter";
     private final static String LEGAL = "legal";
     private final static String EXECUTIVE = "executive";
     private final static String A4 = "a4";
 
     private Properties props;
 
     private String options = ""; // REMIND: needs implementation
 
     /**
      * The thread on which PrinterJob is running.
      * This is different than the applications thread.
      */
     private Thread printerJobThread;
 
     public PrintJob2D(Frame frame,  String doctitle,
                       final Properties props) {
         this.props = props;
         this.jobAttributes = new JobAttributes();
         this.pageAttributes = new PageAttributes();
         translateInputProps();
         initPrintJob2D(frame, doctitle,
                        this.jobAttributes, this.pageAttributes);
     }
 
     public PrintJob2D(Frame frame,  String doctitle,
                       JobAttributes jobAttributes,
                       PageAttributes pageAttributes) {
         initPrintJob2D(frame, doctitle, jobAttributes, pageAttributes);
     }
 
     private void initPrintJob2D(Frame frame,  String doctitle,
                                 JobAttributes jobAttributes,
                                 PageAttributes pageAttributes) {
 
         SecurityManager security = System.getSecurityManager();
         if (security != null) {
             security.checkPrintJobAccess();
         }
 
         if (frame == null &&
             (jobAttributes == null ||
              jobAttributes.getDialog() == DialogType.NATIVE)) {
             throw new NullPointerException("Frame must not be null");
         }
         this.frame = frame;
 
         this.docTitle = (doctitle == null) ? "" : doctitle;
         this.jobAttributes = (jobAttributes != null)
             ? jobAttributes : new JobAttributes();
         this.pageAttributes = (pageAttributes != null)
             ? pageAttributes : new PageAttributes();
 
         // Currently, we always reduce page ranges to xxx or xxx-xxx
         int[][] pageRanges = this.jobAttributes.getPageRanges();
         int first = pageRanges[0][0];
         int last = pageRanges[pageRanges.length - 1][1];
         this.jobAttributes.setPageRanges(new int[][] {
             new int[] { first, last }
         });
         this.jobAttributes.setToPage(last);
         this.jobAttributes.setFromPage(first);
 
 
         // Verify that the cross feed and feed resolutions are the same
         int[] res = this.pageAttributes.getPrinterResolution();
         if (res[0] != res[1]) {
             throw new IllegalArgumentException("Differing cross feed and feed"+
                                                " resolutions not supported.");
         }
 
         // Verify that the app has access to the file system
         DestinationType dest= this.jobAttributes.getDestination();
         if (dest == DestinationType.FILE) {
             throwPrintToFile();
 
             // check if given filename is valid
             String destStr = jobAttributes.getFileName();
             if ((destStr != null) &&
                 (jobAttributes.getDialog() == JobAttributes.DialogType.NONE)) {
 
                 File f = new File(destStr);
                 try {
                     // check if this is a new file and if filename chars are valid
                     // createNewFile returns false if file exists
                     if (f.createNewFile()) {
                         f.delete();
                     }
                 } catch (IOException ioe) {
                     throw new IllegalArgumentException("Cannot write to file:"+
                                                        destStr);
                 } catch (SecurityException se) {
                     //There is already file read/write access so at this point
                     // only delete access is denied.  Just ignore it because in
                     // most cases the file created in createNewFile gets overwritten
                     // anyway.
                 }
 
                  File pFile = f.getParentFile();
                  if ((f.exists() &&
                       (!f.isFile() || !f.canWrite())) ||
                      ((pFile != null) &&
                       (!pFile.exists() || (pFile.exists() && !pFile.canWrite())))) {
                      throw new IllegalArgumentException("Cannot write to file:"+
                                                         destStr);
                  }
             }
         }
     }
 
     public boolean printDialog() {
 
         boolean proceedWithPrint = false;
 
         printerJob = PrinterJob.getPrinterJob();
         if (printerJob == null) {
             return false;
         }
         DialogType d = this.jobAttributes.getDialog();
         PrintService pServ = printerJob.getPrintService();
         if ((pServ == null) &&  (d == DialogType.NONE)){
             return false;
         }
         copyAttributes(pServ);
 
         DefaultSelectionType select =
             this.jobAttributes.getDefaultSelection();
         if (select == DefaultSelectionType.RANGE) {
             attributes.add(SunPageSelection.RANGE);
         } else if (select == DefaultSelectionType.SELECTION) {
             attributes.add(SunPageSelection.SELECTION);
         } else {
             attributes.add(SunPageSelection.ALL);
         }
 
         if (frame != null) {
              attributes.add(new DialogOwner(frame));
          }
 
         if ( d == DialogType.NONE) {
             proceedWithPrint = true;
         } else {
             if (d == DialogType.NATIVE) {
                 attributes.add(DialogTypeSelection.NATIVE);
             }  else { //  (d == DialogType.COMMON)
                 attributes.add(DialogTypeSelection.COMMON);
             }
             if (proceedWithPrint = printerJob.printDialog(attributes)) {
                 if (pServ == null) {
                     // Windows gives an option to install a service
                     // when it detects there are no printers so
                     // we make sure we get the updated print service.
                     pServ = printerJob.getPrintService();
                     if (pServ == null) {
                         return false;
                     }
                 }
                 updateAttributes();
                 translateOutputProps();
             }
         }
 
         if (proceedWithPrint) {
 
             JobName jname = (JobName)attributes.get(JobName.class);
             if (jname != null) {
                 printerJob.setJobName(jname.toString());
             }
 
             pageFormat = new PageFormat();
 
             Media media = (Media)attributes.get(Media.class);
             MediaSize mediaSize =  null;
             if (media != null  && media instanceof MediaSizeName) {
                 mediaSize = MediaSize.getMediaSizeForName((MediaSizeName)media);
             }
 
             Paper p = pageFormat.getPaper();
             if (mediaSize != null) {
                 p.setSize(mediaSize.getX(MediaSize.INCH)*72.0,
                           mediaSize.getY(MediaSize.INCH)*72.0);
             }
 
             if (pageAttributes.getOrigin()==OriginType.PRINTABLE) {
                 // AWT uses 1/4" borders by default
                 p.setImageableArea(18.0, 18.0,
                                    p.getWidth()-36.0,
                                    p.getHeight()-36.0);
             } else {
                 p.setImageableArea(0.0,0.0,p.getWidth(),p.getHeight());
             }
 
             pageFormat.setPaper(p);
 
             OrientationRequested orient =
                (OrientationRequested)attributes.get(OrientationRequested.class);
             if (orient!= null &&
                 orient == OrientationRequested.REVERSE_LANDSCAPE) {
                 pageFormat.setOrientation(PageFormat.REVERSE_LANDSCAPE);
             } else if (orient == OrientationRequested.LANDSCAPE) {
                 pageFormat.setOrientation(PageFormat.LANDSCAPE);
             } else {
                 pageFormat.setOrientation(PageFormat.PORTRAIT);
                 }
 
             printerJob.setPrintable(this, pageFormat);
 
         }
 
         return proceedWithPrint;
     }
 
     private void updateAttributes() {
         Copies c = (Copies)attributes.get(Copies.class);
         jobAttributes.setCopies(c.getValue());
 
         SunPageSelection sel =
             (SunPageSelection)attributes.get(SunPageSelection.class);
         if (sel == SunPageSelection.RANGE) {
             jobAttributes.setDefaultSelection(DefaultSelectionType.RANGE);
         } else if (sel == SunPageSelection.SELECTION) {
             jobAttributes.setDefaultSelection(DefaultSelectionType.SELECTION);
         } else {
             jobAttributes.setDefaultSelection(DefaultSelectionType.ALL);
         }
 
         Destination dest = (Destination)attributes.get(Destination.class);
         if (dest != null) {
             jobAttributes.setDestination(DestinationType.FILE);
             jobAttributes.setFileName(dest.getURI().getPath());
         } else {
             jobAttributes.setDestination(DestinationType.PRINTER);
         }
 
         PrintService serv = printerJob.getPrintService();
         if (serv != null) {
             jobAttributes.setPrinter(serv.getName());
         }
 
         PageRanges range = (PageRanges)attributes.get(PageRanges.class);
         int[][] members = range.getMembers();
         jobAttributes.setPageRanges(members);
 
         SheetCollate collation =
             (SheetCollate)attributes.get(SheetCollate.class);
         if (collation == SheetCollate.COLLATED) {
             jobAttributes.setMultipleDocumentHandling(
             MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_COLLATED_COPIES);
         } else {
             jobAttributes.setMultipleDocumentHandling(
             MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_UNCOLLATED_COPIES);
         }
 
         Sides sides = (Sides)attributes.get(Sides.class);
         if (sides == Sides.TWO_SIDED_LONG_EDGE) {
             jobAttributes.setSides(SidesType.TWO_SIDED_LONG_EDGE);
         } else if (sides == Sides.TWO_SIDED_SHORT_EDGE) {
             jobAttributes.setSides(SidesType.TWO_SIDED_SHORT_EDGE);
         } else {
             jobAttributes.setSides(SidesType.ONE_SIDED);
         }
 
         // PageAttributes
 
         Chromaticity color =
             (Chromaticity)attributes.get(Chromaticity.class);
         if (color == Chromaticity.COLOR) {
             pageAttributes.setColor(ColorType.COLOR);
         } else {
             pageAttributes.setColor(ColorType.MONOCHROME);
         }
 
         OrientationRequested orient =
             (OrientationRequested)attributes.get(OrientationRequested.class);
         if (orient == OrientationRequested.LANDSCAPE) {
             pageAttributes.setOrientationRequested(
                                        OrientationRequestedType.LANDSCAPE);
         } else {
             pageAttributes.setOrientationRequested(
                                        OrientationRequestedType.PORTRAIT);
         }
 
         PrintQuality qual = (PrintQuality)attributes.get(PrintQuality.class);
         if (qual == PrintQuality.DRAFT) {
             pageAttributes.setPrintQuality(PrintQualityType.DRAFT);
         } else if (qual == PrintQuality.HIGH) {
             pageAttributes.setPrintQuality(PrintQualityType.HIGH);
         } else { // NORMAL
             pageAttributes.setPrintQuality(PrintQualityType.NORMAL);
         }
 
         Media msn = (Media)attributes.get(Media.class);
         if (msn != null && msn instanceof MediaSizeName) {
             MediaType mType = unMapMedia((MediaSizeName)msn);
 
             if (mType != null) {
                 pageAttributes.setMedia(mType);
             }
         }
         debugPrintAttributes(false, false);
     }
 
     private void debugPrintAttributes(boolean ja, boolean pa ) {
         if (ja) {
             System.out.println("new Attributes\ncopies = "+
                                jobAttributes.getCopies()+
                                "\nselection = "+
                                jobAttributes.getDefaultSelection()+
                                "\ndest "+jobAttributes.getDestination()+
                                "\nfile "+jobAttributes.getFileName()+
                                "\nfromPage "+jobAttributes.getFromPage()+
                                "\ntoPage "+jobAttributes.getToPage()+
                                "\ncollation "+
                                jobAttributes.getMultipleDocumentHandling()+
                                "\nPrinter "+jobAttributes.getPrinter()+
                                "\nSides2 "+jobAttributes.getSides()
                                );
         }
 
         if (pa) {
             System.out.println("new Attributes\ncolor = "+
                                pageAttributes.getColor()+
                                "\norientation = "+
                                pageAttributes.getOrientationRequested()+
                                "\nquality "+pageAttributes.getPrintQuality()+
                                "\nMedia2 "+pageAttributes.getMedia()
                                );
         }
     }
 
 
     /* From JobAttributes we will copy job name and duplex printing
      * and destination.
      * The majority of the rest of the attributes are reflected
      * attributes.
      *
      * From PageAttributes we copy color, media size, orientation,
      * origin type, resolution and print quality.
      * We use the media, orientation in creating the page format, and
      * the origin type to set its imageable area.
      *
      * REMIND: Interpretation of resolution, additional media sizes.
      */
     private void copyAttributes(PrintService printServ) {
 
         attributes = new HashPrintRequestAttributeSet();
         attributes.add(new JobName(docTitle, null));
         PrintService pServ = printServ;
 
         String printerName = jobAttributes.getPrinter();
         if (printerName != null && printerName != ""
             && !printerName.equals(pServ.getName())) {
 
             // Search for the given printerName in the list of PrintServices
             PrintService []services = PrinterJob.lookupPrintServices();
             try {
                 for (int i=0; i<services.length; i++) {
                     if (printerName.equals(services[i].getName())) {
                         printerJob.setPrintService(services[i]);
                         pServ = services[i];
                         break;
                     }
                 }
             } catch (PrinterException pe) {
             }
         }
 
         DestinationType dest = jobAttributes.getDestination();
         if (dest == DestinationType.FILE &&
             pServ.isAttributeCategorySupported(Destination.class)) {
 
             String fileName = jobAttributes.getFileName();
 
             Destination defaultDest;
             if (fileName == null && (defaultDest = (Destination)pServ.
                     getDefaultAttributeValue(Destination.class)) != null) {
                 attributes.add(defaultDest);
             } else {
                 URI uri = null;
                 try {
                     if (fileName != null) {
                         if (fileName.equals("")) {
                             fileName = ".";
                         }
                     } else {
                         // defaultDest should not be null.  The following code
                         // is only added to safeguard against a possible
                         // buggy implementation of a PrintService having a
                         // null default Destination.
                         fileName = "out.prn";
                     }
                     uri = (new File(fileName)).toURI();
                 } catch (SecurityException se) {
                     try {
                         // '\\' file separator is illegal character in opaque
                         // part and causes URISyntaxException, so we replace
                         // it with '/'
                         fileName = fileName.replace('\\', '/');
                         uri = new URI("file:"+fileName);
                     } catch (URISyntaxException e) {
                     }
                 }
                 if (uri != null) {
                     attributes.add(new Destination(uri));
                 }
             }
         }
         attributes.add(new SunMinMaxPage(jobAttributes.getMinPage(),
                                          jobAttributes.getMaxPage()));
         SidesType sType = jobAttributes.getSides();
         if (sType == SidesType.TWO_SIDED_LONG_EDGE) {
             attributes.add(Sides.TWO_SIDED_LONG_EDGE);
         } else if (sType == SidesType.TWO_SIDED_SHORT_EDGE) {
             attributes.add(Sides.TWO_SIDED_SHORT_EDGE);
         } else if (sType == SidesType.ONE_SIDED) {
             attributes.add(Sides.ONE_SIDED);
         }
 
         MultipleDocumentHandlingType hType =
           jobAttributes.getMultipleDocumentHandling();
         if (hType ==
             MultipleDocumentHandlingType.SEPARATE_DOCUMENTS_COLLATED_COPIES) {
           attributes.add(SheetCollate.COLLATED);
         } else {
           attributes.add(SheetCollate.UNCOLLATED);
         }
 
         attributes.add(new Copies(jobAttributes.getCopies()));
 
         attributes.add(new PageRanges(jobAttributes.getFromPage(),
                                       jobAttributes.getToPage()));
 
         if (pageAttributes.getColor() == ColorType.COLOR) {
             attributes.add(Chromaticity.COLOR);
         } else {
             attributes.add(Chromaticity.MONOCHROME);
         }
 
         pageFormat = printerJob.defaultPage();
         if (pageAttributes.getOrientationRequested() ==
             OrientationRequestedType.LANDSCAPE) {
             pageFormat.setOrientation(PageFormat.LANDSCAPE);
                 attributes.add(OrientationRequested.LANDSCAPE);
         } else {
                 pageFormat.setOrientation(PageFormat.PORTRAIT);
                 attributes.add(OrientationRequested.PORTRAIT);
         }
 
         MediaType media = pageAttributes.getMedia();
         MediaSizeName msn = mapMedia(media);
         if (msn != null) {
             attributes.add(msn);
         }
 
         PrintQualityType qType =
             pageAttributes.getPrintQuality();
         if (qType == PrintQualityType.DRAFT) {
             attributes.add(PrintQuality.DRAFT);
         } else if (qType == PrintQualityType.NORMAL) {
             attributes.add(PrintQuality.NORMAL);
         } else if (qType == PrintQualityType.HIGH) {
             attributes.add(PrintQuality.HIGH);
         }
     }
 
     /**
      * Gets a Graphics object that will draw to the next page.
      * The page is sent to the printer when the graphics
      * object is disposed.  This graphics object will also implement
      * the PrintGraphics interface.
      * @see PrintGraphics
      */
     public Graphics getGraphics() {
 
         Graphics printGraphics = null;
 
         synchronized (this) {
             ++pageIndex;
 
             // Thread should not be created after end has been called.
             // One way to detect this is if any of the graphics queue
             //  has been closed.
             if (pageIndex == 0 && !graphicsToBeDrawn.isClosed()) {
 
             /* We start a thread on which the PrinterJob will run.
              * The PrinterJob will ask for pages on that thread
              * and will use a message queue to fulfill the application's
              * requests for a Graphics on the application's
              * thread.
              */
 
                 startPrinterJobThread();
 
             }
             notify();
         }
 
         /* If the application has already been handed back
          * a graphics then we need to put that graphics into
          * the drawn queue so that the PrinterJob thread can
          * return to the print system.
          */
         if (currentGraphics != null) {
             graphicsDrawn.append(currentGraphics);
             currentGraphics = null;
         }
 
         /* We'll block here until a new graphics becomes
          * available.
          */
 
         currentGraphics = graphicsToBeDrawn.pop();
 
         if (currentGraphics instanceof PeekGraphics) {
             ( (PeekGraphics) currentGraphics).setAWTDrawingOnly();
             graphicsDrawn.append(currentGraphics);
             currentGraphics = graphicsToBeDrawn.pop();
         }
 
 
         if (currentGraphics != null) {
 
             /* In the PrintJob API, the origin is at the upper-
              * left of the imageable area when using the new "printable"
              * origin attribute, otherwise its the physical origin (for
              * backwards compatibility. We emulate this by createing
              * a PageFormat which matches and then performing the
              * translate to the origin. This is a no-op if physical
              * origin is specified.
              */
             currentGraphics.translate(pageFormat.getImageableX(),
                                       pageFormat.getImageableY());
 
             /* Scale to accomodate AWT's notion of printer resolution */
             double awtScale = 72.0/getPageResolutionInternal();
             currentGraphics.scale(awtScale, awtScale);
 
             /* The caller wants a Graphics instance but we do
              * not want them to make 2D calls. We can't hand
              * back a Graphics2D. The returned Graphics also
              * needs to implement PrintGraphics, so we wrap
              * the Graphics2D instance. The PrintJob API has
              * the application dispose of the Graphics so
              * we create a copy of the one returned by PrinterJob.
              */
             printGraphics = new ProxyPrintGraphics(currentGraphics.create(),
                                                    this);
 
         }
 
         return printGraphics;
     }
 
     /**
      * Returns the dimensions of the page in pixels.
      * The resolution of the page is chosen so that it
      * is similar to the screen resolution.
      * Except (since 1.3) when the application specifies a resolution.
      * In that case it it scaled accordingly.
      */
     public Dimension getPageDimension() {
         double wid, hgt, scale;
         if (pageAttributes != null &&
             pageAttributes.getOrigin()==OriginType.PRINTABLE) {
             wid = pageFormat.getImageableWidth();
             hgt = pageFormat.getImageableHeight();
         } else {
             wid = pageFormat.getWidth();
             hgt = pageFormat.getHeight();
         }
         scale = getPageResolutionInternal() / 72.0;
         return new Dimension((int)(wid * scale), (int)(hgt * scale));
     }
 
      private double getPageResolutionInternal() {
         if (pageAttributes != null) {
             int []res = pageAttributes.getPrinterResolution();
             if (res[2] == 3) {
                 return res[0];
             } else /* if (res[2] == 4) */ {
                 return (res[0] * 2.54);
             }
         } else {
             return 72.0;
         }
     }
 
     /**
      * Returns the resolution of the page in pixels per inch.
      * Note that this doesn't have to correspond to the physical
      * resolution of the printer.
      */
     public int getPageResolution() {
         return (int)getPageResolutionInternal();
     }
 
     /**
      * Returns true if the last page will be printed first.
      */
     public boolean lastPageFirst() {
         return false;
     }
 
     /**
      * Ends the print job and does any necessary cleanup.
      */
     public synchronized void end() {
 
         /* Prevent the PrinterJob thread from appending any more
          * graphics to the to-be-drawn queue
          */
         graphicsToBeDrawn.close();
 
         /* If we have a currentGraphics it was the last one returned to the
          * PrintJob client. Append it to the drawn queue so that print()
          * will return allowing the page to be flushed.
          * This really ought to happen in dispose() but for whatever reason
          * that isn't how the old PrintJob worked even though its spec
          * said dispose() flushed the page.
          */
         if (currentGraphics != null) {
             graphicsDrawn.append(currentGraphics);
         }
         graphicsDrawn.closeWhenEmpty();
 
         /* Wait for the PrinterJob.print() thread to terminate, ensuring
          * that RasterPrinterJob has made its end doc call, and resources
          * are released, files closed etc.
          */
         if( printerJobThread != null && printerJobThread.isAlive() ){
             try {
                 printerJobThread.join();
             } catch (InterruptedException e) {
             }
         }
     }
 
     /**
      * Ends this print job once it is no longer referenced.
      * @see #end
      */
     public void finalize() {
         end();
     }
 
     /**
      * Prints the page at the specified index into the specified
      * {@link Graphics} context in the specified
      * format.  A <code>PrinterJob</code> calls the
      * <code>Printable</code> interface to request that a page be
      * rendered into the context specified by
      * <code>graphics</code>.  The format of the page to be drawn is
      * specified by <code>pageFormat</code>.  The zero based index
      * of the requested page is specified by <code>pageIndex</code>.
      * If the requested page does not exist then this method returns
      * NO_SUCH_PAGE; otherwise PAGE_EXISTS is returned.
      * The <code>Graphics</code> class or subclass implements the
      * {@link PrinterGraphics} interface to provide additional
      * information.  If the <code>Printable</code> object
      * aborts the print job then it throws a {@link PrinterException}.
      * @param graphics the context into which the page is drawn
      * @param pageFormat the size and orientation of the page being drawn
      * @param pageIndex the zero based index of the page to be drawn
      * @return PAGE_EXISTS if the page is rendered successfully
      *         or NO_SUCH_PAGE if <code>pageIndex</code> specifies a
      *         non-existent page.
      * @exception java.awt.print.PrinterException
      *         thrown when the print job is terminated.
      */
     public int print(Graphics graphics, PageFormat pageFormat, int pageIndex)
                  throws PrinterException {
 
         int result;
 
         /* This method will be called by the PrinterJob on a thread other
          * that the application's thread. We hold on to the graphics
          * until we can rendevous with the application's thread and
          * hand over the graphics. The application then does all the
          * drawing. When the application is done drawing we rendevous
          * again with the PrinterJob thread and release the Graphics
          * so that it knows we are done.
          */
 
         /* Add the graphics to the message queue of graphics to
          * be rendered. This is really a one slot queue. The
          * application's thread will come along and remove the
          * graphics from the queue when the app asks for a graphics.
          */
         graphicsToBeDrawn.append( (Graphics2D) graphics);
 
         /* We now wait for the app's thread to finish drawing on
          * the Graphics. This thread will sleep until the application
          * release the graphics by placing it in the graphics drawn
          * message queue. If the application signals that it is
          * finished drawing the entire document then we'll get null
          * returned when we try and pop a finished graphic.
          */
         if (graphicsDrawn.pop() != null) {
             result = PAGE_EXISTS;
         } else {
             result = NO_SUCH_PAGE;
         }
 
         return result;
     }
 
     private void startPrinterJobThread() {
 
         printerJobThread = new Thread(this, "printerJobThread");
         printerJobThread.start();
     }
 
 
     public void run() {
 
         try {
             printerJob.print(attributes);
         } catch (PrinterException e) {
             //REMIND: need to store this away and not rethrow it.
         }
 
         /* Close the message queues so that nobody is stuck
          * waiting for one.
          */
         graphicsToBeDrawn.closeWhenEmpty();
         graphicsDrawn.close();
     }
 
     private class MessageQ {
 
         private String qid="noname";
 
         private ArrayList queue = new ArrayList();
 
         MessageQ(String id) {
           qid = id;
         }
 
         synchronized void closeWhenEmpty() {
 
             while (queue != null && queue.size() > 0) {
                 try {
                     wait(1000);
                 } catch (InterruptedException e) {
                     // do nothing.
                 }
             }
 
             queue = null;
             notifyAll();
         }
 
         synchronized void close() {
             queue = null;
             notifyAll();
         }
 
         synchronized boolean append(Graphics2D g) {
 
             boolean queued = false;
 
             if (queue != null) {
                 queue.add(g);
                 queued = true;
                 notify();
             }
 
             return queued;
         }
 
         synchronized Graphics2D pop() {
             Graphics2D g = null;
 
             while (g == null && queue != null) {
 
                 if (queue.size() > 0) {
                     g = (Graphics2D) queue.remove(0);
                     notify();
 
                 } else {
                     try {
                         wait(2000);
                     } catch (InterruptedException e) {
                         // do nothing.
                     }
                 }
             }
 
             return g;
         }
 
         synchronized boolean isClosed() {
             return queue == null;
         }
 
     }
 
 
     private static int[] getSize(MediaType mType) {
         int []dim = new int[2];
         dim[0] = 612;
         dim[1] = 792;
 
         for (int i=0; i < SIZES.length; i++) {
             if (SIZES[i] == mType) {
                 dim[0] = WIDTHS[i];
                 dim[1] = LENGTHS[i];
                 break;
             }
         }
         return dim;
     }
 
     public static MediaSizeName mapMedia(MediaType mType) {
         MediaSizeName media = null;
 
         // JAVAXSIZES.length and SIZES.length must be equal!
         // Attempt to recover by getting the smaller size.
         int length = Math.min(SIZES.length, JAVAXSIZES.length);
 
         for (int i=0; i < length; i++) {
             if (SIZES[i] == mType) {
                 if ((JAVAXSIZES[i] != null) &&
                     MediaSize.getMediaSizeForName(JAVAXSIZES[i]) != null) {
                     media = JAVAXSIZES[i];
                     break;
                 } else {
                     /* create Custom Media */
                     media = new CustomMediaSizeName(SIZES[i].toString());
 
                     float w = (float)Math.rint(WIDTHS[i]  / 72.0);
                     float h = (float)Math.rint(LENGTHS[i] / 72.0);
                     if (w > 0.0 && h > 0.0) {
                         // add new created MediaSize to our static map
                         // so it will be found when we call findMedia
                         new MediaSize(w, h, Size2DSyntax.INCH, media);
                     }
 
                     break;
                 }
             }
         }
         return media;
     }
 
 
     public static MediaType unMapMedia(MediaSizeName mSize) {
         MediaType media = null;
 
         // JAVAXSIZES.length and SIZES.length must be equal!
         // Attempt to recover by getting the smaller size.
         int length = Math.min(SIZES.length, JAVAXSIZES.length);
 
         for (int i=0; i < length; i++) {
             if (JAVAXSIZES[i] == mSize) {
                 if (SIZES[i] != null) {
                     media = SIZES[i];
                     break;
                 }
             }
         }
         return media;
     }
 
     private void translateInputProps() {
         if (props == null) {
             return;
         }
 
         String str;
 
         str = props.getProperty(DEST_PROP);
         if (str != null) {
             if (str.equals(PRINTER)) {
                 jobAttributes.setDestination(DestinationType.PRINTER);
             } else if (str.equals(FILE)) {
                 jobAttributes.setDestination(DestinationType.FILE);
             }
         }
         str = props.getProperty(PRINTER_PROP);
         if (str != null) {
             jobAttributes.setPrinter(str);
         }
         str = props.getProperty(FILENAME_PROP);
         if (str != null) {
             jobAttributes.setFileName(str);
         }
         str = props.getProperty(NUMCOPIES_PROP);
         if (str != null) {
             jobAttributes.setCopies(Integer.parseInt(str));
         }
 
         this.options = props.getProperty(OPTIONS_PROP, "");
 
         str = props.getProperty(ORIENT_PROP);
         if (str != null) {
             if (str.equals(PORTRAIT)) {
                 pageAttributes.setOrientationRequested(
                                         OrientationRequestedType.PORTRAIT);
             } else if (str.equals(LANDSCAPE)) {
                 pageAttributes.setOrientationRequested(
                                         OrientationRequestedType.LANDSCAPE);
             }
         }
         str = props.getProperty(PAPERSIZE_PROP);
         if (str != null) {
             if (str.equals(LETTER)) {
                 pageAttributes.setMedia(SIZES[MediaType.LETTER.hashCode()]);
             } else if (str.equals(LEGAL)) {
                 pageAttributes.setMedia(SIZES[MediaType.LEGAL.hashCode()]);
             } else if (str.equals(EXECUTIVE)) {
                 pageAttributes.setMedia(SIZES[MediaType.EXECUTIVE.hashCode()]);
             } else if (str.equals(A4)) {
                 pageAttributes.setMedia(SIZES[MediaType.A4.hashCode()]);
             }
         }
     }
 
     private void translateOutputProps() {
         if (props == null) {
             return;
         }
 
         String str;
 
         props.setProperty(DEST_PROP,
             (jobAttributes.getDestination() == DestinationType.PRINTER) ?
                           PRINTER : FILE);
         str = jobAttributes.getPrinter();
         if (str != null && !str.equals("")) {
             props.setProperty(PRINTER_PROP, str);
         }
         str = jobAttributes.getFileName();
         if (str != null && !str.equals("")) {
             props.setProperty(FILENAME_PROP, str);
         }
         int copies = jobAttributes.getCopies();
         if (copies > 0) {
             props.setProperty(NUMCOPIES_PROP, "" + copies);
         }
         str = this.options;
         if (str != null && !str.equals("")) {
             props.setProperty(OPTIONS_PROP, str);
         }
         props.setProperty(ORIENT_PROP,
             (pageAttributes.getOrientationRequested() ==
              OrientationRequestedType.PORTRAIT)
                           ? PORTRAIT : LANDSCAPE);
         MediaType media = SIZES[pageAttributes.getMedia().hashCode()];
         if (media == MediaType.LETTER) {
             str = LETTER;
         } else if (media == MediaType.LEGAL) {
             str = LEGAL;
         } else if (media == MediaType.EXECUTIVE) {
             str = EXECUTIVE;
         } else if (media == MediaType.A4) {
             str = A4;
         } else {
             str = media.toString();
         }
         props.setProperty(PAPERSIZE_PROP, str);
     }
 
     private void throwPrintToFile() {
         SecurityManager security = System.getSecurityManager();
         FilePermission printToFilePermission = null;
         if (security != null) {
             if (printToFilePermission == null) {
                 printToFilePermission =
                     new FilePermission("<<ALL FILES>>", "read,write");
             }
             security.checkPermission(printToFilePermission);
         }
     }
 
 }